//我认为，在修改边的任何操作中，前提是边的顶点一定存在，所以需要在前端显示所有顶点。

const express = require('express');
const router = express.Router();
const db = require('./db');
const mysql = require('mysql2/promise');


// 获取所有边信息
//调用方法http://127.0.0.1:3000/api/edge/edge
router.get('/edge', (req, res) => {
    db.query('SELECT * FROM edge', (err, results) => {
      if (err) {
        console.error('Error querying database: ' + err.stack);
        res.status(500).json({ error: 'Database error' });
        return;
      }
      console.log(`请求所有地点成功`);  
      res.json(results);
    });
  });
  
/*返回信息如下 
[
    {
        "id": 1,
        "from_node": "A",
        "to_node": "B",
        "weight": 3
    },
    {
        "id": 2,
        "from_node": "A",
        "to_node": "C",
        "weight": 5
    },
    {
        "id": 3,
        "from_node": "B",
        "to_node": "C",
        "weight": 1
    },
    {
        "id": 4,
        "from_node": "B",
        "to_node": "C",
        "weight": 3
    }
]
*/ 


  
//查询某一条边
//调用方法http://127.0.0.1:3000/api/edge/edge/find
/*要附带一个JSON表单id可以为空，顶点可以相反
{
        "id": 4,
        "from_node": "B",
        "to_node": "C"
}
*/
router.post('/edge/find', (req, res) => {
  const edgeId = req.body.id; // 获取边的 ID
  const fromNode = req.body.from_node; // 获取起始节点信息
  const toNode = req.body.to_node; // 获取目标节点信息
  
  // 构建查询条件
  let query = 'SELECT * FROM edge WHERE ';
  let queryParams = [];

  if (edgeId) {
    // 如果提供了ID，则添加ID条件
    query += 'id = ? AND ';
    queryParams.push(edgeId);
  }

  // 无向边的两种可能顺序
  query += '((from_node = ? AND to_node = ?) OR (from_node = ? AND to_node = ?))';
  queryParams.push(fromNode, toNode, toNode, fromNode);

  // 执行查询
  db.query(query, queryParams, (error, results, fields) => {
      if (error) {
          console.error(error);
          res.status(500).json({ error: 'Internal Server Error' });
      } else {
          if (results.length === 0) {
              res.status(404).json({ error: '没有找到符合条件的边' }); // 返回没有找到边的错误提示
          } else {
              res.json(results[0]);  // 返回所有查询结果
          }
      }
  });
});
  
//调用方法http://127.0.0.1:3000/api/edge/edge/add
/* 添加边使用方法：输入你的 JSON 数据，例如：
json
{  
  "from_node": "1",  
  "to_node": "2",  
  "weight": 5  
}
*/
router.post('/edge/add', (req, res) => {
  const { from_node, to_node, weight } = req.body;

  // 检查必需的字段是否都已提供
  if (!from_node || !to_node || !weight) {
    return res.status(400).json({ error: 'Missing required fields: from_node, to_node, weight' });
  }

  // 检查顶点是否存在
  const checkVerticesQuery = 'SELECT * FROM locations WHERE spotname IN (?, ?)';
  db.query(checkVerticesQuery, [from_node, to_node], (error, results) => {
    if (error) {
      console.error(error);
      return res.status(500).json({ error: 'Internal Server Error' });
    }

    // 确保两个顶点都存在
    if (results.length !== 2) {
      return res.status(400).json({ error: 'One or both vertices do not exist' });
    }

    // 顶点存在，继续添加边
    const addEdgeQuery = 'INSERT INTO edge (from_node, to_node, weight) VALUES (?, ?, ?)';
    db.query(addEdgeQuery, [from_node, to_node, weight], (insertError, insertResults) => {
      if (insertError) {
        console.error(insertError);
        return res.status(500).json({ error: 'Internal Server Error' });
      }

      // 注意：MySQL的INSERT操作通常不会返回插入的行，除非使用了特殊的返回语句
      // 但我们可以使用insertId属性来获取最后插入行的ID（如果数据库支持）
      if (insertResults.insertId) {
        res.json({ id: insertResults.insertId, message: 'Edge added successfully' });
      } else {
        // 如果数据库不支持insertId，或者出于某种原因没有返回它，您可以简单地返回一个成功的消息
        res.json({ message: 'Edge added successfully' });
      }
    });
  });
});
  



  // 更新边的路由http://127.0.0.1:3000/api/edge/update
  //提供JSON表单
  /*
{  
  "id":5,
  "from_node": "1",  
  "to_node": "2",  
  "weight": 888 
}
*/
router.put('/update', (req, res) => {
  const { id, from_node, to_node, weight } = req.body;

  // 检查必需的字段是否都已提供
  if (!id || !from_node || !to_node || !weight) {
    return res.status(400).json({ error: 'Missing required fields: id, from_node, to_node, weight' });
  }

  // 检查顶点是否存在
  const checkVerticesQuery = 'SELECT * FROM locations WHERE spotname IN (?, ?)';
  db.query(checkVerticesQuery, [from_node, to_node], (error, results) => {
    if (error) {
      console.error(error);
      return res.status(500).json({ error: 'Internal Server Error' });
    }

    // 确保两个顶点都存在
    if (results.length !== 2) {
      return res.status(400).json({ error: 'One or both vertices do not exist' });
    }

    // 顶点存在，继续更新边
    const updateEdgeQuery = 'UPDATE edge SET from_node = ?, to_node = ?, weight = ? WHERE id = ?';
    db.query(updateEdgeQuery, [from_node, to_node, weight, id], (updateError, updateResults) => {
      if (updateError) {
        console.error(updateError);
        return res.status(500).json({ error: 'Internal Server Error' });
      }

      if (updateResults.affectedRows === 0) {
        return res.status(404).json({ error: 'No edge found with the given id' });
      }

      res.json({ message: 'Edge updated successfully' });
    });
  });
});


  // 删除边// 更新边的路由http://127.0.0.1:3000/api/edge/delete
  //提供JSON表单
  /*
{  
  "id":5
}
*/
  router.delete('/delete', (req, res) => {
    const edgeToDelete = req.body; // 从请求体中获取要删除的边信息

    if (!edgeToDelete || !edgeToDelete.id) {
        return res.status(400).json({ error: 'Missing required field: id' });
    }

    const query = 'DELETE FROM edge WHERE id = ?'; // 构造删除语句
    
    db.query(query, [edgeToDelete.id], (error, results, fields) => {
        if (error) {
            console.error(error);
            return res.status(500).json({ error: 'Internal Server Error' });
        }

        if (results.affectedRows === 0) {
            return res.status(404).json({ error: 'No edge found with the given id' });
        }

        res.json({ message: 'Edge deleted successfully' });
    });
});


  module.exports = router;